home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / alpha / dipc / dipc-0.000 / dipc-0 / dipc-0.15 / dipcd / referee.c < prev    next >
C/C++ Source or Header  |  1996-07-16  |  23KB  |  878 lines
  1. /*
  2.  * referee.c
  3.  *
  4.  * part of dipcd source code
  5.  *
  6.  * Copyright (C) Kamran Karimi
  7.  */
  8.  
  9. #include "dipcd.h"
  10. #include "funcs.h"
  11.  
  12. #include "back_door.h"
  13.  
  14. char back_ux_name[80];
  15.  
  16. /* for the status field. All received queries first have the REF_WAITING 
  17.    state. After an answer is sent to them, they are in REF_ANSWERED state.
  18.    When the successfully create the IPC structure, they will be promoted to
  19.    REF_NORMAL state */
  20. #define REF_WAITING  0
  21. #define REF_ANSWERED 1
  22. #define REF_NORMAL   2
  23.  
  24. extern struct sockaddr_in REFEREE_ADDRESS;
  25.  
  26. extern int verbose;
  27. extern int global_timeout;
  28. extern int referee_timeout;
  29.  
  30. static char ipc_type[3][4] = 
  31. {
  32.  "SHM",
  33.  "MSG",
  34.  "SEM"
  35. };
  36.  
  37. struct dipc_list 
  38. {
  39.  key_t key;
  40.  int size;
  41.  int distrib;
  42.  int status;
  43.  int pid;
  44.  int mode;
  45.  time_t answer_time;
  46.  struct sockaddr_in address;
  47.  struct dipc_info info;
  48.  struct dipc_list *next,*prev;
  49. };
  50. /* There are six queue in the referee. They are divided into two main types. 
  51.    The three queues in each type are one for shared memories, one for message
  52.    queues, and one for semaphore sets. The 'wanted' linked list is for new 
  53.    queries to search for a key. If the corresponding structures are 
  54.    successfully created in the local, the corresponding element will be 
  55.    brought to the 'gotten' linked list */
  56. struct dipc_list gotten_first[3];
  57. struct dipc_list *gotten_last[3];
  58.  
  59. struct dipc_list wanted_first[3];
  60. struct dipc_list *wanted_last[3];
  61.  
  62.  
  63. static void add_to_list(struct dipc_list **last, struct dipc_list *dl)
  64. {
  65.  dl->next = NULL;
  66.  dl->prev = *last;
  67.  (*last)->next = dl;
  68.  *last = dl;
  69. }
  70.  
  71. static struct dipc_list *find_in_list(struct dipc_list *first, int key)
  72. {
  73.  struct dipc_list *dl2 = first->next;
  74.  
  75.  while(dl2)
  76.  {
  77.   if(dl2->info.key == key)
  78.    break;
  79.   dl2 = dl2->next;
  80.  }
  81.  return dl2;
  82. }
  83.  
  84. static void remove_from_list(struct dipc_list **last, struct dipc_list *dl)
  85. {
  86.  if(dl == *last)
  87.   (*last) = (*last)->prev; 
  88.  (dl->prev)->next = dl->next;
  89.  if(dl->next)
  90.   (dl->next)->prev = dl->prev;
  91. }
  92.  
  93. static struct dipc_list *get_next_key(struct dipc_list *dl)
  94. {
  95.  struct dipc_list *dl2 = dl->next;
  96.  
  97.  while(dl2)
  98.  {
  99.   if(dl2->info.key == dl->info.key) 
  100.    break;
  101.   dl2 = dl2->next;
  102.  }
  103.  return dl2;
  104. } 
  105.  
  106. /* searches to see if it can find a registered key that is the same as the 
  107.    one in the query. It sends this information to the computer that asked
  108.    for it */ 
  109. static BOOLEAN respond_to(struct dipc_list *query)
  110. {
  111.  struct message response;
  112.  struct dipc_list *dl;
  113.  int type;
  114.  
  115.  response.info = query->info;  
  116.  response.address = REFEREE_ADDRESS;
  117.  response.pid = query->pid;
  118.  response.request = RES_REFEREE;
  119.  
  120.  type = query->info.type;
  121.  dl = find_in_list(&gotten_first[type], query->key);
  122.  if(dl)
  123.  {
  124.   if(verbose)
  125.   {
  126.    sprintf(mstr,"Found Existing Key %d of type %s From %s",
  127.            dl->key,ipc_type[type], inet_ntoa(dl->address.sin_addr));
  128.    mess(mstr, INFO);
  129.   }
  130.   response.info.arg3 = dl->size;
  131.   response.info.arg4 = dl->address.sin_addr.s_addr;
  132.   if(dl->distrib)
  133.   {
  134.    if(verbose)
  135.    {
  136.     sprintf(mstr,"found DIPC");
  137.     mess(mstr, INFO);
  138.    } 
  139.    response.info.arg2 = FOUND_DIPC;
  140.   }
  141.   else
  142.   {
  143.    if(verbose)
  144.    {
  145.     sprintf(mstr,"found IPC");
  146.     mess(mstr, INFO);
  147.    }
  148.    response.info.arg2 = FOUND_IPC; 
  149.   }  
  150.   /* sprintf(mstr,"owner address is %s",inet_ntoa(dl->address.sin_addr));
  151.      mess(mstr, INFO); */
  152.  }
  153.  else
  154.  { /* no gotten found */
  155.   if(verbose)
  156.   {
  157.    sprintf(mstr,"key not found");
  158.    mess(mstr, INFO);
  159.   }
  160.   response.info.arg3 = 0;
  161.   response.info.arg4 = query->address.sin_addr.s_addr; /* its own address */
  162.   response.info.arg2 = NOT_FOUND;
  163.  } 
  164.  if(send_in_message(&response, query->address) == FAIL)
  165.  {
  166.   sprintf(mstr,"ERROR: Can't Return Result Of Search");
  167.   mess(mstr, INFO);
  168.   remove_from_list(&wanted_last[type], query);
  169.   free(query);
  170.   return FAIL;
  171.  }
  172.  query->status = REF_ANSWERED;
  173.  query->answer_time = time(NULL); 
  174.  return SUCCESS;
  175. }
  176.  
  177.  
  178. /* Places the query in the 'wanted' linked list and then conducts a search 
  179.    in the referee linked lists. If the query can be answered, it will
  180.    call respond_to, otherwise it has to wait for the results of earlier 
  181.    queries */
  182. static BOOLEAN referee_dipc_search(struct message *message)
  183. {
  184.  struct dipc_list *dl, *dl2;
  185.  int type = message->info.type;
  186.  
  187.  if(verbose)
  188.  {
  189.   sprintf(mstr,"Handling Search For Key %d of type %s",
  190.             message->info.key, ipc_type[type]);
  191.   mess(mstr, INFO);
  192.  }
  193.  /* we should put the request in a linked list, waiting for a commit answer. */  
  194.  dl2 = (struct dipc_list *)malloc(sizeof(struct dipc_list));
  195.  if(dl2 == NULL)
  196.  {
  197.   sprintf(mstr,"ERROR: No Mem");
  198.   mess(mstr, INFO);
  199.   return FAIL;
  200.  }
  201.  dl2->key = message->info.key;
  202.  dl2->pid = message->pid;
  203.  dl2->info = message->info;
  204.  dl2->size = message->info.arg3;
  205.  dl2->distrib = message->info.arg2;
  206.  dl2->status = REF_WAITING;
  207.  if(verbose)
  208.  {
  209.   if(dl2->distrib)
  210.   {
  211.    sprintf(mstr,"new request is DIPC");
  212.    mess(mstr, INFO);
  213.   }  
  214.   else
  215.   {
  216.    sprintf(mstr,"new request is IPC");
  217.    mess(mstr, INFO);
  218.   }  
  219.  }  
  220.  dl2->address = message->address;
  221.  
  222.  /* see if another one is already waiting. do this before putting the new 
  223.     query in the list. */
  224.  dl = find_in_list(&wanted_first[type], message->info.key);
  225.  /* now put the new query in the list */
  226.  add_to_list(&wanted_last[type], dl2);
  227.  if(dl)
  228.  { /* found another query, the new one should wait */
  229.   if(verbose)
  230.   {
  231.    sprintf(mstr,"Key %d Must Wait",message->info.key);    
  232.    mess(mstr, INFO);
  233.   }
  234.  }
  235.  else
  236.  {
  237.   /* this is the only request. answer it now */
  238.   if(FAIL == respond_to(dl2))
  239.    return FAIL;
  240.  }
  241.  return SUCCESS; 
  242. }
  243.  
  244.  
  245. /* handles the commit messages. If the structure is created in the local
  246.    machine, the request will be put in the 'gotten' linked list. otherwise
  247.    it is thrown away. In any case it is checked to see if other quesries
  248.    have been waiting for this result, and they are informed accordingly. */
  249. static BOOLEAN referee_dipc_commit(struct message *message)
  250. {
  251.  struct dipc_list *dl, *dl2, *dl3;
  252.  struct message response;
  253.  int type;
  254.  
  255.  if(verbose)
  256.  {
  257.   sprintf(mstr,"Handling Commit For Key %d of Type %s",
  258.           message->info.key, ipc_type[message->info.type]);
  259.   mess(mstr, INFO);
  260.  }        
  261.  type = message->info.type;             
  262.  response = *message;
  263.  response.address = REFEREE_ADDRESS;
  264.  /* this may be used to inform other tasks of the search result */
  265.  
  266.  response.request = RES_REFEREE;
  267.  /* find the corresponding in the 'wanted' linked list */
  268.  dl = find_in_list(&wanted_first[type], message->info.key);
  269.  while(dl)
  270.  {
  271.   if(SAME_MACHINE(&(dl->address),message->address))
  272.    break;
  273.   dl = get_next_key(dl);
  274.  } 
  275.  if(dl == NULL)
  276.  {
  277.   sprintf(mstr,"ERROR: Commit For Non-Existing Key");
  278.   mess(mstr, INFO);
  279.   return FAIL;
  280.  }
  281.  else
  282.  {
  283.   /* in any case remove the request from wanted list, because either it
  284.      will be thrown away (failer) or put in another linked list (success) */ 
  285.   remove_from_list(&wanted_last[type], dl);        
  286.   if(message->info.arg2 > 0)
  287.   { /* successful COMMIT. put it in existing dipc list */
  288.    if(verbose)
  289.    {
  290.     sprintf(mstr,"Commit: Success");
  291.     mess(mstr, INFO);
  292.    } 
  293.    dl->status = REF_NORMAL;
  294.    dl->mode = message->info.arg3;
  295.    dl->size = message->info.arg2;
  296.     
  297.    add_to_list(&gotten_last[type], dl);         
  298.    /* we should also return FOUND to all the other waiting tasks.
  299.       search from the start and call respond_to */
  300.    dl2 = find_in_list(&wanted_first[type], dl->key);
  301.    while(dl2) 
  302.    {
  303.     dl3 = get_next_key(dl2);
  304.     if(respond_to(dl2) == FAIL)
  305.     {
  306.      sprintf(mstr,"ERROR: Can't Respond To Request");
  307.      mess(mstr, INFO);
  308.     }
  309.     dl2 = dl3;
  310.    }
  311.   }
  312.   else
  313.   {  /* failed commit. remove it and give a chance to another machine */
  314.    if(verbose)
  315.    {
  316.     sprintf(mstr,"Commit: No success");
  317.     mess(mstr, INFO);
  318.    }
  319.    dl2 = get_next_key(dl);
  320.    while(dl2)
  321.    {
  322.     if(SUCCESS == respond_to(dl2))
  323.      break;
  324.     dl2 = get_next_key(dl2); 
  325.    }
  326.    /* destroy the failed request */
  327.    free(dl);   
  328.   }
  329.  }
  330.  /* the process sending the commit is waiting inside its local kernel.
  331.     We have to answer it, so it can continue. */
  332.  response = *message;
  333.  response.address = REFEREE_ADDRESS;
  334.  response.request = RES_REFEREE;
  335.  if(send_in_message(&response, message->address) == FAIL)
  336.  {
  337.   /* don't worry. The worker that sent the commit message will timeout */
  338.   sprintf(mstr,"ERORR: Can't Restart The Commit: %s",
  339.           inet_ntoa(dl2->address.sin_addr));
  340.   mess(mstr, INFO);        
  341.   return FAIL;
  342.  }
  343.  if(verbose)
  344.  {
  345.   sprintf(mstr,"key %d Commit Done",message->info.key);
  346.   mess(mstr, INFO);
  347.  }             
  348.  return SUCCESS;
  349. }
  350.  
  351.  
  352. /* a request to delete a key in referee linked lists. It also checks to see
  353.    if it should inform a shared memory manager process to detach */
  354. static BOOLEAN referee_dipc_delkey(struct message *message)
  355. {
  356.  struct message response;
  357.  struct dipc_list *dl, *dl2;
  358.  int type;
  359.  
  360.  if(verbose)
  361.  {
  362.   sprintf(mstr,"Handling Delete Of Key %d of Type %s",
  363.          message->info.key, ipc_type[message->info.type]);
  364.   mess(mstr, INFO);
  365.  }       
  366.  type = message->info.type;                    
  367.  dl = find_in_list(&gotten_first[type], message->info.key);
  368.  while(dl)
  369.  {
  370.   if(SAME_MACHINE(&(dl->address), message->address))
  371.    break;
  372.   dl = get_next_key(dl);
  373.  } 
  374.  if(dl == NULL)
  375.  {
  376.   sprintf(mstr,"ERROR: There Is No Key To Delete");
  377.   mess(mstr, INFO);
  378.   /* return FAIL; don't return fail, so that the stoped task can resatart */
  379.  } 
  380.  else
  381.  {
  382.   if(verbose)
  383.   {
  384.    if(dl->mode & IPC_OWN)
  385.    {
  386.     sprintf(mstr,"This Is The Owner");
  387.     mess(mstr, INFO);
  388.    }
  389.    else
  390.    {
  391.     sprintf(mstr,"This Isn't The Owner");
  392.     mess(mstr, INFO);
  393.    }  
  394.   }  
  395.   remove_from_list(&gotten_last[type], dl); 
  396.   /* now see if there is only one remaining machine with the key.
  397.      if this is the case and the key type is SHM, send a message 
  398.      to that machine, so that the key_manager can detach itself */
  399.   dl2 = find_in_list(&gotten_first[type], message->info.key);   
  400.   if(type == SHM && dl2 && get_next_key(dl2) == NULL) 
  401.   {
  402.    if(verbose)
  403.    {    
  404.     sprintf(mstr,"Only Machine %s Has This Shared Memory Key",
  405.            inet_ntoa(dl->address.sin_addr));
  406.     mess(mstr, INFO);
  407.    }       
  408.    response = *message;
  409.    response.address = REFEREE_ADDRESS;
  410.    response.request = REQ_SHMMAN;
  411.    response.info.func = DETACH;
  412.    if(send_in_message(&response, dl2->address) == FAIL)
  413.    {
  414.     sprintf(mstr,"ERROR: Can't Inform Shared Memory Owner To Delete");
  415.     mess(mstr, INFO); 
  416.     /* return FAIL; don't return fail, so that the stoped task can resatart */  
  417.    }  
  418.   }
  419.   free(dl); 
  420.  }
  421.  /* in any case, come here and send a reply to original task */
  422.  response = *message;
  423.  response.address = REFEREE_ADDRESS;
  424.  response.request = RES_REFEREE;
  425.  if(send_in_message(&response, message->address) == FAIL)
  426.  {
  427.   sprintf(mstr,"ERORR: Can't Restart The Delete at %s",
  428.                           inet_ntoa(message->address.sin_addr));
  429.   mess(mstr, INFO);
  430.   return FAIL;
  431.  } 
  432.  if(verbose)
  433.  {    
  434.   sprintf(mstr,"key %d Delete Acknowledge Done",message->info.key);   
  435.   mess(mstr, INFO);
  436.  }
  437.  return SUCCESS; 
  438. }
  439.  
  440.  
  441.  
  442. /* a request to remove an IPC structure. This one is comming from the owner
  443.    of the structure. Inform other computers with a structure of the same 
  444.    key */
  445. static BOOLEAN referee_dipc_rmid(struct message *message)
  446. {
  447.  struct message response;
  448.  struct dipc_list *dl, *dl2;
  449.  int type = message->info.type;
  450.  int key = message->info.key;
  451.  
  452.  if(verbose)
  453.  {
  454.   sprintf(mstr,"Handling RMID Of Key %d of Type %s",key, ipc_type[type]); 
  455.   mess(mstr, INFO);
  456.  }
  457.  dl = find_in_list(&gotten_first[type], key);
  458.  while(dl)
  459.  {
  460.   if(SAME_MACHINE(&(dl->address), message->address))
  461.    break;
  462.   dl = get_next_key(dl);
  463.  }
  464.  if(dl == NULL)
  465.  {
  466.   sprintf(mstr,"ERROR: There Is No Key To RMID");
  467.   mess(mstr, INFO);
  468.   /* return FAIL; don't return fail, so that the stoped task can resatart */
  469.  } 
  470.  else
  471.  {  
  472.   response = *message;
  473.   response.address = REFEREE_ADDRESS;
  474.   response.request = REQ_DOWORK;
  475.   /* send all the keys except the first one */ 
  476.   dl2 = find_in_list(&gotten_first[type], key);
  477.   while(dl2)
  478.   {
  479.    if(dl2 != dl) /* not the original one! */
  480.    {
  481.     if(verbose)
  482.     {
  483.      sprintf(mstr,"telling key %d of type %s at %s to RMID",dl2->key, 
  484.               ipc_type[type], inet_ntoa(dl2->address.sin_addr));
  485.      mess(mstr, INFO);
  486.     }                      
  487.     if(send_in_message(&response, dl2->address) == FAIL)
  488.     { 
  489.      sprintf(mstr,"Can't Tell key %d of type %s at %s to RMID",dl2->key, 
  490.                  ipc_type[type], inet_ntoa(dl2->address.sin_addr));
  491.      mess(mstr, INFO);
  492.      /* return FAIL; don't return fail, so that the stoped task can resatart */
  493.     }
  494.    }  
  495.    dl2 = get_next_key(dl2);
  496.   }
  497.   /* now see if there is only one machine with the key. This happens 
  498.     when all the tasks are on the same machine.
  499.     If this is the case and the key type is SHM, send a message 
  500.     to that machine, so that the key_manager can detach itself */
  501.   dl2 = find_in_list(&gotten_first[type], key);  
  502.   if(type == SHM && dl2 && get_next_key(dl2) == NULL)
  503.   {
  504.    if(verbose)
  505.    {    
  506.     sprintf(mstr,"Only Machine %s Has This Shared Memory Key",
  507.             inet_ntoa(dl->address.sin_addr));
  508.     mess(mstr, INFO);
  509.    }
  510.    response = *message;
  511.    response.address = REFEREE_ADDRESS;
  512.    response.request = REQ_SHMMAN;
  513.    response.info.func = DETACH;
  514.    if(send_in_message(&response, dl2->address) == FAIL)
  515.    {
  516.     sprintf(mstr,"ERROR: Can't Inform Shared Memory Owner To Delete");
  517.     mess(mstr, INFO);
  518.     /* return FAIL; don't return fail, so that the stoped task can resatart */  
  519.    } 
  520.   }
  521.  } /* if dl */     
  522.  /*sprintf(mstr,"acknowledging the RMID");
  523.    mess(mstr, INFO); */
  524.  response = *message;
  525.  response.address = REFEREE_ADDRESS;
  526.  response.request = RES_REFEREE;
  527.  if(send_in_message(&response, message->address) == FAIL)
  528.   return FAIL;
  529.  if(verbose)
  530.  {    
  531.   sprintf(mstr,"Key %d RMID Acknowledge Done",key);
  532.   mess(mstr, INFO);
  533.  }
  534.  return SUCCESS; 
  535. }
  536.  
  537.      
  538. static void sig_handler(int signo)
  539. {
  540.  if(verbose)
  541.  {
  542.   sprintf(mstr,"Quiting For Signal No. %d",signo);
  543.   mess(mstr, INFO);
  544.  }
  545.  /* do last works */
  546.  unlink(back_ux_name); /* remove the back_door socket */
  547.  exit(5);
  548. }
  549.  
  550.  
  551. /* checks for stale requests and if timed out, fakes a failed commit.
  552.    This is called at regular intervals */
  553. void check_answers(void)
  554. {
  555.  int type;
  556.  struct message message;
  557.  time_t curr_time;
  558.  struct dipc_list *dl;
  559.  
  560.  if(referee_timeout <= 0 || global_timeout == 0) return;
  561.  
  562.  message.request = RES_REFEREE;
  563.  message.info.arg2 = 0; /* FAIL */
  564.  curr_time = time(NULL);
  565.  for(type = 0; type < 3; type++)
  566.  {
  567.   dl = wanted_first[type].next;
  568.   while(dl)
  569.   {
  570.    if(dl->status == REF_ANSWERED)
  571.    {
  572.     if((curr_time - dl->answer_time) > referee_timeout)
  573.     {
  574.      if(verbose)
  575.      {
  576.       sprintf(mstr,"Handling Stale request at %s",
  577.               inet_ntoa(dl->address.sin_addr));
  578.       mess(mstr, INFO);
  579.      }        
  580.      message.address = dl->address;
  581.      message.info = dl->info;
  582.      message.info.func = COMMIT;
  583.      referee_dipc_commit(&message);
  584.     }
  585.    }
  586.    dl = dl->next;
  587.   }
  588.  }
  589. }
  590.  
  591. /* the back_door control center. It receives request from the UNIX domain 
  592.    socket and executes them. This is for 'out of band' control of the referee,
  593.    without the need to redesign it. The work here should be done quickly, 
  594.    because while the referee is handling back_door requests, it won't be 
  595.    able to handle normal, more important requests. */
  596. static void bd_work_on(int ux_sockfd, struct back_door_message *bd_message)
  597. {
  598.  struct dipc_list *dl;
  599.  struct back_door_message bd_response;
  600.  int type, want_trans, act_trans;
  601.  
  602.  switch(bd_message->cmd)
  603.  {
  604.   case BACK_DOOR_INFO:
  605.    if(verbose)
  606.    { 
  607.     sprintf(mstr,"back door: request for information\n");
  608.     mess(mstr, INFO);
  609.    } 
  610.    /* display the information for shared memories, message queues, and
  611.       semaphore sets */
  612.    for(type = 0; type < 3; type++)
  613.    {
  614.     dl = gotten_first[type].next;
  615.     while(dl)
  616.     {
  617.      bd_response.arg1 = type;
  618.      bd_response.arg2 = dl->key;
  619.      bd_response.arg3 = dl->size;
  620.      bd_response.arg4 = dl->distrib;
  621.      bd_response.arg5 = dl->address.sin_addr.s_addr;
  622.      want_trans = sizeof(bd_response);
  623.      act_trans = writen(ux_sockfd, (char *)&bd_response, want_trans);
  624.      if(act_trans < want_trans)
  625.      {
  626.       sprintf(mstr,"ERROR: sent %d From %d Bytes  BECAUSE %s",
  627.             act_trans, want_trans,strerror(errno));
  628.       mess(mstr, INFO);
  629.       break;        
  630.      }
  631.      dl = dl->next;
  632.     }
  633.     if(dl != NULL) break;
  634.    }
  635.    if(type == 3)
  636.    {
  637.     /* this signals the end of information */ 
  638.     bd_response.arg1 = -1;
  639.     want_trans = sizeof(bd_response);
  640.     act_trans = writen(ux_sockfd, (char *)&bd_response, want_trans);
  641.     if(act_trans < want_trans)
  642.     {
  643.      sprintf(mstr,"ERROR: sent %d From %d Bytes  BECAUSE %s",
  644.            act_trans, want_trans,strerror(errno));
  645.      mess(mstr, INFO);        
  646.     }
  647.    }
  648.    break;
  649.   case BACK_DOOR_REMOVE:
  650.    if(verbose)
  651.    { 
  652.     sprintf(mstr,"back door: request for removal\n");
  653.     mess(mstr, INFO);
  654.    }
  655.    dl = gotten_first[bd_message->arg1].next;
  656.    while(dl)
  657.    {
  658.     if(dl->key == bd_message->arg2 && 
  659.        dl->address.sin_addr.s_addr == bd_message->arg5)
  660.      break;
  661.     dl = dl->next;
  662.    }
  663.    if(dl)
  664.    {
  665.     remove_from_list(&gotten_last[bd_message->arg1], dl);
  666.     if(verbose)
  667.     { 
  668.      sprintf(mstr,"back door: removed the entry\n");
  669.      mess(mstr, INFO);
  670.     }
  671.     /* tell dipcreg of the success */
  672.     bd_message->arg1 = 0;
  673.    }
  674.    else
  675.    {
  676.     if(verbose)
  677.     { 
  678.      sprintf(mstr,"back door: did not find the entry\n");
  679.      mess(mstr, INFO);
  680.     }
  681.     bd_message->arg1 = -1;
  682.    } 
  683.    want_trans = sizeof(*bd_message);
  684.    act_trans = writen(ux_sockfd, (char *)bd_message, want_trans);
  685.    if(act_trans < want_trans)
  686.    {
  687.     sprintf(mstr,"ERROR: Sent %d From %d Bytes  BECAUSE %s",
  688.           act_trans, want_trans,strerror(errno));
  689.     mess(mstr, INFO);        
  690.    }
  691.    break;
  692.    
  693.   default:
  694.    sprintf(mstr,"ERROR: Unknown back door request: %d\n", bd_message->cmd);
  695.    mess(mstr, INFO);
  696.  }
  697. }
  698.     
  699. void referee(void)
  700. {
  701.  fd_set rSelFD; /* for select */
  702.  struct timeval TimeVal;
  703.  int count;
  704.  int want_trans, act_trans;
  705.  struct message message;
  706.  int in_client_len, in_len;
  707.  struct sockaddr_in in_client_addr, in_addr;
  708.  int in_sockfd,in_newsockfd;
  709.  struct sockaddr_un back_ux_addr, back_ux_client_addr;
  710.  int back_ux_len, back_ux_client_len;
  711.  int back_ux_sockfd, back_ux_newsockfd;
  712.  struct sigaction sact;
  713.  struct back_door_message bd_message;
  714.  
  715.  if(verbose)
  716.  { 
  717.   sprintf(mstr,"referee Started");
  718.   mess(mstr, INFO);
  719.  }
  720.  sact.sa_handler = sig_handler;
  721.  sigemptyset(&sact.sa_mask);
  722.  sact.sa_flags = 0;
  723.  
  724.  if(sigaction(SIGINT, &sact, NULL) < 0)
  725.  {
  726.   sprintf(mstr,"ERROR: Can't Catch Signal  BECAUSE %s",strerror(errno));
  727.   mess(mstr, INFO);
  728.  } 
  729.  if(sigaction(SIGTERM, &sact, NULL ) < 0)
  730.  {
  731.   sprintf(mstr,"ERROR: Can't Catch Signal  BECAUSE %s",strerror(errno));
  732.   mess(mstr, INFO);
  733.  } 
  734.  if(sigaction(SIGSEGV, &sact, NULL) < 0)
  735.  {
  736.   sprintf(mstr,"ERROR: Can't Catch Signal  BECAUSE %s",strerror(errno));
  737.  } 
  738.  
  739.  for(count = 0; count < 3; count++)
  740.  {
  741.   gotten_first[count].next = gotten_first[count].prev = NULL;
  742.   gotten_last[count] = &gotten_first[count];
  743.   
  744.   wanted_first[count].next = wanted_first[count].prev = NULL;
  745.   wanted_last[count] = &wanted_first[count];
  746.  } 
  747.  /* prepare the "back door" socket */
  748.  sprintf(back_ux_name,"%s%s",UNIX_PATH,REFEREE_BACKDOOR);
  749.  bzero((char *)&back_ux_addr,sizeof(back_ux_addr));
  750.  back_ux_addr.sun_family = AF_UNIX;
  751.  strcpy(back_ux_addr.sun_path,back_ux_name);
  752.  back_ux_len = strlen(back_ux_addr.sun_path) + sizeof(back_ux_addr.sun_family); 
  753.  
  754.  unlink(back_ux_name);
  755.  back_ux_sockfd = plug(AF_UNIX, (struct sockaddr *)&back_ux_addr, back_ux_len);
  756.  if(back_ux_sockfd < 0)
  757.  { 
  758.   sprintf(mstr,"ERROR: Can't Create Socket %s",back_ux_name);
  759.   mess(mstr, INFO);
  760.   exit(20);
  761.  }
  762.   
  763.  bzero((char *)&in_addr,sizeof(in_addr));
  764.  in_addr.sin_family = AF_INET;
  765.  in_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  766.  in_addr.sin_port = htons(DIPC_REFEREE_PORT);
  767.  in_len = sizeof(in_addr);
  768.   
  769.  in_sockfd = plug(AF_INET, (struct sockaddr *) &in_addr, in_len);
  770.  if(in_sockfd < 0)
  771.  {
  772.   sprintf(mstr,"ERROR: Can't Create Socket");
  773.   mess(mstr, INFO);
  774.   unlink(back_ux_name);
  775.   exit(20);
  776.  }
  777.  
  778.  while(1) 
  779.  {
  780.   TimeVal.tv_sec = referee_timeout;
  781.   TimeVal.tv_usec = 0;
  782.   FD_ZERO(&rSelFD);
  783.   FD_SET(in_sockfd,&rSelFD);
  784.   FD_SET(back_ux_sockfd, &rSelFD);
  785.   if(select(FD_SETSIZE,&rSelFD,NULL,NULL,&TimeVal) < 0)
  786.   {
  787.    sprintf(mstr,"ERROR: select() failed  BECAUSE %s",strerror(errno));
  788.    mess(mstr, INFO);
  789.    close(in_sockfd);
  790.    unlink(back_ux_name);
  791.    exit(20);
  792.   }  
  793.   if(FD_ISSET(in_sockfd,&rSelFD))
  794.   {
  795.    in_client_len = sizeof(in_client_addr);
  796.    if((in_newsockfd = accept(in_sockfd, (struct sockaddr *)&in_client_addr,
  797.                                                       &in_client_len)) < 0)
  798.    {
  799.     sprintf(mstr,"ERROR: accept() Failed  BECAUSE %s",strerror(errno));
  800.     mess(mstr, INFO);
  801.     close(in_sockfd);
  802.     unlink(back_ux_name);
  803.     exit(20);
  804.    }
  805.    want_trans = sizeof(message);
  806.    act_trans = get_in_message(in_newsockfd, &message);
  807.    if(act_trans < want_trans)
  808.    {
  809.     sprintf(mstr,"ERROR: Received %d From %d Bytes  BECAUSE %s",
  810.             act_trans, want_trans,strerror(errno));
  811.     mess(mstr, INFO);        
  812.    }
  813.    else
  814.    {
  815.     if(verbose)
  816.     {
  817.      sprintf(mstr,"Remote Call From %s",inet_ntoa(message.address.sin_addr)); 
  818.      mess(mstr, INFO);
  819.     }
  820.  
  821.     switch(message.info.func)
  822.     {
  823.      case SEARCH:
  824.       referee_dipc_search(&message);
  825.       break;
  826.      case COMMIT:
  827.       referee_dipc_commit(&message); 
  828.       break;
  829.      case DELKEY:
  830.       referee_dipc_delkey(&message);
  831.       break;
  832.      case RMID:
  833.       referee_dipc_rmid(&message);  
  834.       break;
  835.      default: 
  836.       sprintf(mstr,"ERROR: Unknown Request %s",
  837.                                    request_string(message.request)); 
  838.       mess(mstr, INFO);
  839.       break;
  840.     }
  841.    } /* message received */  
  842.    close(in_newsockfd);
  843.   }
  844.   else if(FD_ISSET(back_ux_sockfd,&rSelFD))
  845.   {
  846.    if(verbose)
  847.    {
  848.     sprintf(mstr,"back door call");
  849.     mess(mstr, INFO);
  850.    }  
  851.    back_ux_client_len = sizeof(back_ux_client_addr);
  852.    if((back_ux_newsockfd = accept(back_ux_sockfd, 
  853.          (struct sockaddr *)&back_ux_client_addr, &back_ux_client_len)) < 0)
  854.    {
  855.     sprintf(mstr,"ERROR: accept() Failed  BECAUSE %s",strerror(errno));
  856.     mess(mstr, INFO);
  857.     close(back_ux_newsockfd);
  858.    }
  859.    else
  860.    {
  861.     want_trans = sizeof(bd_message);
  862.     act_trans = readn(back_ux_newsockfd,(char *)&bd_message, want_trans);
  863.     if(act_trans < want_trans)
  864.     {
  865.      sprintf(mstr,"ERROR: Received %d From %d Bytes  BECAUSE %s",
  866.             act_trans, want_trans,strerror(errno));
  867.      mess(mstr, INFO);        
  868.     }
  869.     else
  870.      bd_work_on(back_ux_newsockfd, &bd_message);
  871.     close(back_ux_newsockfd);
  872.    } 
  873.   } /* if back door */ 
  874.   /* either a timeout or a request was serviced, check stale requests */
  875.   check_answers();
  876.  } /* while(1) */
  877. }
  878.